home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Games / Arashi 1.1.1 / source code / Game Source / jam src / GridTest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-13  |  9.2 KB  |  431 lines  |  [TEXT/KAHL]
  1. /*/
  2.      Project Arashi: GridTest.c
  3.      Major release: Version 1.1d2, 9/5/95
  4.  
  5.      Last modification: Thursday, January 13, 1994, 7:34
  6.      Created: Thursday, February 9, 1989, 22:32
  7.  
  8.      Copyright © 1989-1994, Juri Munkki
  9. /*/
  10.  
  11. #include <Math.h>
  12. #include "VA.h"
  13. #define    _MAKEGRID_
  14. #include "STORM.h"
  15. #include "heroflags.h"
  16.  
  17. #define PI 3.1415926535
  18.  
  19. #define    FIELDADVANCE    8
  20. #define    FIELDSTART        (2*DEPTH)
  21.  
  22. extern    Player    Hero;
  23.  
  24. int        xcen;
  25. int        ycen;
  26.  
  27. int        FieldDistance;
  28.  
  29. #define    DOSTARRIDE
  30.  
  31. extern    int        StarsUsed;
  32. extern    Point    NewStarTwist;
  33.  
  34. void    FieldRide(
  35.     worldstruct    *world,
  36.     short        fieldAdvance)
  37. {
  38.     int        i;
  39.     int        x[MAXSEGS],y[MAXSEGS];
  40.     int        xb[MAXSEGS],yb[MAXSEGS];
  41.     
  42.     if(!VA.Late)
  43.     {    VA.color=0;
  44.         if(FieldDistance<STARTDEPTH*2)
  45.                 VA.color=0;
  46.         else    VA.color=(FieldDistance-STARTDEPTH)*7/(FIELDSTART-STARTDEPTH-1);
  47.         
  48.         if(VA.color > 6) VA.color = 6;
  49.  
  50.         for(i=0;i<=ww.numsegs;i++)
  51.         {    x[i]=((world->x[i]-world->xoff)*STARTDEPTH)
  52.                     /(long)(STARTDEPTH+FieldDistance)+xcen+world->xoff;
  53.             y[i]=((world->y[i]-world->yoff)*STARTDEPTH)
  54.                     /(long)(STARTDEPTH+FieldDistance)+ycen+world->yoff;
  55.             xb[i]=((world->x[i]-world->xoff)*STARTDEPTH)
  56.                     /(long)(STARTDEPTH+DEPTH+FieldDistance)+xcen+world->xoff;
  57.             yb[i]=((world->y[i]-world->yoff)*STARTDEPTH)
  58.                     /(long)(STARTDEPTH+DEPTH+FieldDistance)+ycen+world->yoff;
  59.             
  60.             VAMoveTo(x[i],y[i]);
  61.             VASafeLineTo(xb[i],yb[i]);
  62.         }
  63.         VAMoveTo(x[0],y[0]);
  64.         for(i=1;i<=ww.numsegs;i++)
  65.         {    VASafeLineTo(x[i],y[i]);
  66.         }
  67.     
  68.         VAMoveTo(xb[0],yb[0]);
  69.         for(i=1;i<=ww.numsegs;i++)
  70.         {    VASafeLineTo(xb[i],yb[i]);
  71.         }
  72.     }
  73.     
  74.     FieldDistance += fieldAdvance;
  75.     if(FieldDistance<0)    FieldDistance=0;
  76. }
  77. void    StarStep()
  78. {
  79. #ifdef    DOSTARRIDE
  80. #ifdef BACKGROUND_FRIENDLY
  81.         GameEvent();
  82. #endif
  83.         FeedStars();
  84.         RideStars();
  85.         VAStep();
  86. #endif
  87. }
  88. void    StarsOut()
  89. {
  90. #ifdef DOSTARRIDE
  91.     if(StarsUsed)        
  92.     {    RideStars();
  93.     }
  94. #endif
  95. }
  96.  
  97. void DoZapRecharge(onoff)
  98. int onoff;
  99. {
  100.     /* This next section will add the message             */
  101.     /* "Superzapper recharge" to the screen (mz)        */
  102.     
  103.     unsigned char    *text=(void *)"\pSuperzapper Recharge";
  104.     int                x,y;
  105.     
  106.     if(Hero.Flags & ShowSuperZapMsgMask)
  107.     {
  108.         VA.segmscale = (int)(Getfontscale() * 1.5);
  109.         if(VA.segmscale <=1) 
  110.             VA.segmscale=2;
  111.         x = (int)( (VA.frame.right - 20*(VA.segmscale*3 + 3))/2 );
  112.         y = (int)(VA.frame.bottom - 2);
  113.         VAMoveTo(x,y);
  114.         VA.color=BG1;
  115.         if (!onoff)                    /* Erase option */
  116.             VA.color = -1;        
  117.         VADrawText((char *)text,1,20);
  118.     }
  119. }
  120.  
  121. void    MakeSpots(world)
  122. worldstruct    *world;
  123. {
  124.     register    int        d,i,j;
  125.  
  126.     ww.numsegs=world->numsegs;
  127.     ww.wraps=world->wraps;
  128.  
  129.     for(d=ZOOMDEPTH;d<=DEPTH;d++)
  130.     {    for(i=0;i<=ww.numsegs;i++)
  131.         {    ww.x[i][d]=((world->x[i]-world->xoff)*(long)STARTDEPTH)
  132.                             /(STARTDEPTH+d)+xcen+world->xoff;
  133.             ww.y[i][d]=((world->y[i]-world->yoff)*(long)STARTDEPTH)
  134.                             /(STARTDEPTH+d)+ycen+world->yoff;
  135.         }
  136.         ww.unitlen[d]=(world->unitlen * (long)STARTDEPTH) / (STARTDEPTH+d);
  137.         if(!(d & 31))
  138.             StarStep();
  139.     }
  140.  
  141.  
  142.     for(d=ZOOMDEPTH+1;d<DEPTH+1;d++)
  143.     {    for(i=0;i<ww.numsegs;i++)
  144.         {    ww.xc[i][d]=(ww.x[i][d]+ww.x[i+1][d])>>1;
  145.             ww.yc[i][d]=(ww.y[i][d]+ww.y[i+1][d])>>1;
  146.         }
  147.         if(!(d & 15))
  148.         {    StarsOut();
  149.             if(StarsUsed)
  150.             {    VAStep();
  151. #ifdef BACKGROUND_FRIENDLY
  152.                 GameEvent();
  153. #endif
  154.             }
  155.         }
  156.     }
  157.  
  158.     FieldDistance=FIELDSTART; 
  159.  
  160.     /*    Precalculate paths for spinning stars at center of playfield:    */
  161.     ww.starsegs=ww.numsegs*STARDIVISION;
  162.     for(d=0;d<2;d++)
  163.     {    for(i=0;i<=ww.numsegs;i++)
  164.         {    ww.starx[i*STARDIVISION][d]=((world->x[i]-world->xoff)*(long)STARTDEPTH)
  165.                             /(STARTDEPTH+DEPTH+(DEPTH*2)*d)+xcen+world->xoff;
  166.             ww.stary[i*STARDIVISION][d]=((world->y[i]-world->yoff)*(long)STARTDEPTH)
  167.                             /(STARTDEPTH+DEPTH+(DEPTH*2)*d)+ycen+world->yoff;
  168.         }
  169.         for(i=0;i<ww.starsegs;i+=STARDIVISION)
  170.         {    for(j=1;j<STARDIVISION;j++)
  171.             {    ww.starx[i+j][d]=(ww.starx[i+STARDIVISION][d]-ww.starx[i][d])*j/STARDIVISION+
  172.                                   ww.starx[i][d];
  173.                 ww.stary[i+j][d]=(ww.stary[i+STARDIVISION][d]-ww.stary[i][d])*j/STARDIVISION+
  174.                                   ww.stary[i][d];
  175.             }
  176.             if(FieldDistance)
  177.             {    FieldRide(world,-FIELDADVANCE);
  178.                 StarsOut();
  179. #ifdef BACKGROUND_FRIENDLY
  180.                 GameEvent();
  181. #endif
  182.                 VAStep();
  183.             }
  184.         }
  185.     }
  186.  
  187.     if(FieldDistance)
  188.     {    while(FieldDistance)
  189.         {    FieldRide(world,-FIELDADVANCE);
  190. #ifdef BACKGROUND_FRIENDLY
  191.             GameEvent();
  192. #endif
  193.             VAStep();
  194.         }
  195.         
  196.         VA.Late=0;
  197.     }
  198.     FieldRide(world,-FIELDADVANCE);
  199.     VAStep();
  200.  
  201.     {    int        mode;
  202.         
  203.         mode=QD32COMPATIBLE;
  204.         SwapMMUMode(&mode);
  205.     
  206.         VA.field=1;        VA.offset=1;        VA.color=0;
  207.     
  208.         for(i=0;i<ww.numsegs;i++)
  209.         {    VABresenham(ww.x[i][0],ww.y[i][0],ww.x[i][DEPTH],ww.y[i][DEPTH]);
  210.         }
  211.         if(ww.wraps==0)
  212.             VABresenham(ww.x[i][0],ww.y[i][0],ww.x[i][DEPTH],ww.y[i][DEPTH]);
  213.         
  214.         for(d=0;d<=DEPTH;d+=DEPTH)
  215.         {    for(i=0;i<ww.numsegs;i++)
  216.             {    VABresenham(ww.x[i][d],ww.y[i][d],ww.x[i+1][d],ww.y[i+1][d]);
  217.             }
  218.         }
  219.         VA.field=3;
  220.         SwapMMUMode(&mode);
  221.     }
  222.     VAStep();
  223.     VASetColors(GetResource('CLOT',ThisLevel.lvColor));
  224.     VACatchUp();
  225.  
  226. }
  227.  
  228. void    CreateFit()
  229. {
  230.  
  231.     register    double    x,y,sx,sy;
  232.     register    int        i,j,k;
  233.     register    shape    *space;
  234.                 double    xmin,xmax,ymin,ymax,a;
  235.     register    shape    **spacehand;
  236.  
  237.     double        AngularConstant= PI * 2.0 / ANGLES;
  238.  
  239.  
  240.     if (ThisLevel.lvColor != 5)            /* Use alternate grey for invis levels (mz) */
  241.         OpenStars(GetResource('CLOT',ThisLevel.lvColor));
  242.     else
  243.         OpenStars(GetResource('CLOT',ThisLevel.lvColor + 128));
  244.  
  245.     VA.segmscale=(VA.frame.bottom>>6);
  246.     if(VA.segmscale<1) VA.segmscale=1;
  247.     k=VA.color;
  248.     VA.color=BG2;
  249.     if (ThisLevel.lvColor == 5)        /* check for invis BG2 on ivis waves (mz) */
  250.         VA.color=BG1;
  251.     VADrawNumber(ThisLevel.lvNumber,VA.frame.right/2-VA.segmscale-3,VA.segmscale*2+4);
  252.     VA.color=k;
  253.         
  254.     DoZapRecharge(1);                /* (mz) */
  255.  
  256.     spacehand=(void *)GetResource('SPCE',ThisLevel.lvField);
  257.     HLock(spacehand);
  258.     space=*spacehand;
  259.     
  260.     gridOutline.numsegs=space->numsegs;
  261.     if(gridOutline.numsegs>=MAXSEGS-1) DebugStr("\PToo many shape segments error");
  262.     xmin=xmax=ymin=ymax=x=y=0.0;
  263.     a=0.0;
  264.     
  265.     for(i=0;i<space->numsegs;i++)
  266.     {    double    TempAngle;
  267.     
  268.         a+=space->ang[i];
  269.         TempAngle=a*AngularConstant;
  270.         x+= cos(TempAngle);
  271.         y-= sin(TempAngle);
  272.         if(x<xmin)    xmin=x;
  273.         else
  274.         if(x>xmax)    xmax=x;
  275.         if(y<ymin)    ymin=y;
  276.         else
  277.         if(y>ymax)    ymax=y;
  278.         
  279.         StarStep();
  280.     }
  281.  
  282. #define    TWIST_DIVIDE    32
  283.  
  284.     {    /*    Change margins to account for twist.    */
  285.     
  286.         double    xshift,yshift,normalmargin;
  287.         double    twistBot;
  288.  
  289.         normalmargin = 1.05;
  290.         xmin -= normalmargin;
  291.         ymin -= normalmargin;
  292.         xmax += normalmargin;
  293.         ymax += normalmargin;
  294.  
  295.         xshift = space->xoff/(double)TWIST_DIVIDE;
  296.         yshift = space->yoff/(double)TWIST_DIVIDE;
  297.     
  298.         twistBot = (xmax - xshift) * (long)STARTDEPTH / (DEPTH+STARTDEPTH) + xshift;
  299.         if(twistBot > xmax)        xmax = twistBot;
  300.     
  301.         twistBot = (xmin - xshift) * (long)STARTDEPTH / (DEPTH+STARTDEPTH) + xshift;
  302.         if(twistBot < xmin)        xmin = twistBot;
  303.     
  304.         twistBot = (ymax - yshift) * (long)STARTDEPTH / (DEPTH+STARTDEPTH) + yshift;
  305.         if(twistBot > ymax)        ymax = twistBot;
  306.     
  307.         twistBot = (ymin - yshift) * (long)STARTDEPTH / (DEPTH+STARTDEPTH) + yshift;
  308.         if(twistBot < ymin)        ymin = twistBot;
  309.     
  310.     }
  311.  
  312.     x = -(xmin+xmax)/2;
  313.     y = -(ymin+ymax)/2;
  314.     
  315.     xcen=(VA.frame.right+VA.frame.left)/2;
  316.     ycen=(VA.frame.bottom+VA.frame.top)/2;
  317.     
  318.     sx=(VA.frame.right-VA.frame.left)/(xmax-xmin);
  319.     sy=(VA.frame.bottom-VA.frame.top)/(ymax-ymin);
  320.     if(sy<sx)    sx=sy;
  321.  
  322.     gridOutline.xoff=space->xoff*sx/TWIST_DIVIDE;
  323.     gridOutline.yoff=space->yoff*sx/TWIST_DIVIDE;
  324.  
  325.     NewStarTwist.h=gridOutline.xoff;
  326.     NewStarTwist.v=gridOutline.yoff;
  327.     
  328.     gridOutline.unitlen= sx;
  329.     x= sx * x + 0.5;
  330.     y= sx * y + 0.5;
  331.     a=0.0;
  332.     for(i=0;i<space->numsegs;i++)
  333.     {    double    TempAngle;
  334.     
  335.         a+=space->ang[i];
  336.         TempAngle=a*AngularConstant;
  337.  
  338.         gridOutline.x[i]=x;
  339.         gridOutline.y[i]=y;
  340.         
  341.         x+= cos(TempAngle)*sx;
  342.         y-= sin(TempAngle)*sx;
  343.         
  344.         StarStep();
  345.     }
  346.         
  347.     gridOutline.x[i]=x;
  348.     gridOutline.y[i]=y;
  349.     gridOutline.wraps=space->wraps;
  350.     if(space->wraps)
  351.     {    gridOutline.x[i]=gridOutline.x[0];
  352.         gridOutline.y[i]=gridOutline.y[0];
  353.     }
  354.  
  355.     j=0;
  356.     for(i=0;i<space->numsegs;i++)
  357.     {    j+=space->ang[i];
  358.         NextSeg[i]=(j+4*ANGLES) % ANGLES;
  359.     }
  360.     NextSeg[i]=NextSeg[0];
  361.  
  362.     for(i=0;i<=space->numsegs;i++)
  363.     {    PrevSeg[i]=(ANGLES/2+NextSeg[(i-1+space->numsegs) % space->numsegs]) % ANGLES;
  364.     }
  365.     
  366.     for(i=0;i<=space->numsegs;i++)
  367.     {    k=(NextSeg[i]+PrevSeg[i])/2;
  368.         if(NextSeg[i]<k) k+=ANGLES/2;
  369.  
  370.         for(j=k;j<k+ANGLES/2;j++)
  371.             LaneSel[i][j % ANGLES]=i;
  372.         for(j=k+ANGLES/2;j<k+ANGLES;j++)
  373.             LaneSel[i][j % ANGLES]=i-1;
  374.             
  375.         if(!(i & 7)) StarStep();
  376.     }
  377.     
  378.     
  379.     for(j=0;j<ANGLES;j++)
  380.         if(LaneSel[0][j]==-1)
  381.             LaneSel[0][j]=space->numsegs-1;
  382.  
  383.     StarStep();
  384.  
  385.     DoZapRecharge(0);                /* (mz) */
  386.     
  387.     for(j=k;j<k+ANGLES/2;j++)
  388.         LaneSel[space->numsegs][j % ANGLES]=0;
  389.  
  390.     StarStep();
  391.  
  392.     if(space->wraps==0)
  393.      {    PrevSeg[0]=-999;
  394.          NextSeg[space->numsegs]=-999;
  395.          for(j=0;j<ANGLES;j++)
  396.          {    LaneSel[0][j]=0;
  397.              LaneSel[space->numsegs][j]=space->numsegs-1;
  398.          }
  399.      }
  400.  
  401.     StarStep();
  402.     HUnlock(spacehand);
  403.     MakeSpots(&gridOutline);
  404.  
  405.     ReleaseResource(spacehand);
  406.     CloseStars();
  407. }
  408.  
  409. void    AllocGrids()
  410. {
  411.     register    int        *ip;
  412.     register    char    *cp;
  413.     register    int        i;
  414.     
  415.     ip=(int *)NewPtr(            (DEPTH-ZOOMDEPTH+1L)*sizeof(int)+
  416.                         MAXSEGS*(DEPTH-ZOOMDEPTH+1L)*sizeof(int)*4+
  417.                                  (MAXSEGS+1L)*ANGLES*sizeof(char));
  418.     for(i=0;i<MAXSEGS;i++)
  419.     {    ww.x[i]=ip-ZOOMDEPTH;        ip+=DEPTH-ZOOMDEPTH+1;
  420.         ww.y[i]=ip-ZOOMDEPTH;        ip+=DEPTH-ZOOMDEPTH+1;
  421.         ww.xc[i]=ip-ZOOMDEPTH;        ip+=DEPTH-ZOOMDEPTH+1;
  422.         ww.yc[i]=ip-ZOOMDEPTH;        ip+=DEPTH-ZOOMDEPTH+1;
  423.     }
  424.     ww.unitlen=ip-ZOOMDEPTH;
  425.     ip+=DEPTH-ZOOMDEPTH+1;
  426.  
  427.     cp=(char *)ip;
  428.     for(i=0;i<=MAXSEGS;i++)
  429.     {    LaneSel[i]=cp;    cp+=ANGLES;
  430.     }
  431. }